Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume12/cnews/part12

Internet Message Format | 1987-10-22 | 40.0 KB

Subject:  v12i037:  C News alpha release, Part12/14
Newsgroups: comp.sources.unix
Sender: sources
Approved: [e-mail]

Submitted-by: utzoo!henry (Henry Spencer)
Posting-number: Volume 12, Issue 37
Archive-name: cnews/part12

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 12 (of 14)."
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'libc/strings/tester.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'libc/strings/tester.c'\"
else
echo shar: Extracting \"'libc/strings/tester.c'\" \(19922 characters\)
sed "s/^X//" >'libc/strings/tester.c' <<'END_OF_FILE'
X/*
X * Test program for string(3) routines.
X *
X * Note that at least one Bell Labs implementation of the string
X * routines flunks a couple of these tests -- the ones which test
X * behavior on "negative" characters.
X */
X
X#include <stdio.h>
X#include <string.h>
X
X#define    STREQ(a, b)    (strcmp((a), (b)) == 0)
X
Xchar *it = "<UNSET>";        /* Routine name for message routines. */
Xint waserror = 0;        /* For exit status. */
X
Xchar uctest[] = "\004\203";    /* For testing signedness of chars. */
Xint charsigned;            /* Result. */
X
X/*
X - check - complain if condition is not true
X */
Xvoid
Xcheck(thing, number)
Xint thing;
Xint number;            /* Test number for error message. */
X{
X    if (!thing) {
X        printf("%s flunked test %d\n", it, number);
X        waserror = 1;
X    }
X}
X
X/*
X - equal - complain if first two args don't strcmp as equal
X */
Xvoid
Xequal(a, b, number)
Xchar *a;
Xchar *b;
Xint number;            /* Test number for error message. */
X{
X    check(a != NULL && b != NULL && STREQ(a, b), number);
X}
X
Xchar one[50];
Xchar two[50];
X
X#ifdef UNIXERR
X#define ERR 1
X#endif
X#ifdef BERKERR
X#define ERR 1
X#endif
X#ifdef ERR
Xint f;
Xextern char *sys_errlist[];
Xextern int sys_nerr;
Xextern int errno;
X#endif
X
X/* ARGSUSED */
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X    /*
X     * First, establish whether chars are signed.
X     */
X    if (uctest[0] < uctest[1])
X        charsigned = 0;
X    else
X        charsigned = 1;
X
X    /*
X     * Then, do the rest of the work.  Split into two functions because
X     * some compilers get unhappy about a single immense function.
X     */
X    first();
X    second();
X
X    exit((waserror) ? 1 : 0);
X}
X
Xfirst()
X{
X    /*
X     * Test strcmp first because we use it to test other things.
X     */
X    it = "strcmp";
X    check(strcmp("", "") == 0, 1);        /* Trivial case. */
X    check(strcmp("a", "a") == 0, 2);    /* Identity. */
X    check(strcmp("abc", "abc") == 0, 3);    /* Multicharacter. */
X    check(strcmp("abc", "abcd") < 0, 4);    /* Length mismatches. */
X    check(strcmp("abcd", "abc") > 0, 5);
X    check(strcmp("abcd", "abce") < 0, 6);    /* Honest miscompares. */
X    check(strcmp("abce", "abcd") > 0, 7);
X    check(strcmp("a\203", "a") > 0, 8);    /* Tricky if char signed. */
X    if (charsigned)                /* Sign-bit comparison. */
X        check(strcmp("a\203", "a\003") < 0, 9);
X    else
X        check(strcmp("a\203", "a\003") > 0, 9);
X
X    /*
X     * Test strcpy next because we need it to set up other tests.
X     */
X    it = "strcpy";
X    check(strcpy(one, "abcd") == one, 1);    /* Returned value. */
X    equal(one, "abcd", 2);            /* Basic test. */
X
X    (void) strcpy(one, "x");
X    equal(one, "x", 3);            /* Writeover. */
X    equal(one+2, "cd", 4);            /* Wrote too much? */
X
X    (void) strcpy(two, "hi there");
X    (void) strcpy(one, two);
X    equal(one, "hi there", 5);        /* Basic test encore. */
X    equal(two, "hi there", 6);        /* Stomped on source? */
X
X    (void) strcpy(one, "");
X    equal(one, "", 7);            /* Boundary condition. */
X
X    /*
X     * strcat
X     */
X    it = "strcat";
X    (void) strcpy(one, "ijk");
X    check(strcat(one, "lmn") == one, 1);    /* Returned value. */
X    equal(one, "ijklmn", 2);        /* Basic test. */
X
X    (void) strcpy(one, "x");
X    (void) strcat(one, "yz");
X    equal(one, "xyz", 3);            /* Writeover. */
X    equal(one+4, "mn", 4);            /* Wrote too much? */
X
X    (void) strcpy(one, "gh");
X    (void) strcpy(two, "ef");
X    (void) strcat(one, two);
X    equal(one, "ghef", 5);            /* Basic test encore. */
X    equal(two, "ef", 6);            /* Stomped on source? */
X
X    (void) strcpy(one, "");
X    (void) strcat(one, "");
X    equal(one, "", 7);            /* Boundary conditions. */
X    (void) strcpy(one, "ab");
X    (void) strcat(one, "");
X    equal(one, "ab", 8);
X    (void) strcpy(one, "");
X    (void) strcat(one, "cd");
X    equal(one, "cd", 9);
X
X    /*
X     * strncat - first test it as strcat, with big counts, then
X     * test the count mechanism.
X     */
X    it = "strncat";
X    (void) strcpy(one, "ijk");
X    check(strncat(one, "lmn", 99) == one, 1);    /* Returned value. */
X    equal(one, "ijklmn", 2);        /* Basic test. */
X
X    (void) strcpy(one, "x");
X    (void) strncat(one, "yz", 99);
X    equal(one, "xyz", 3);            /* Writeover. */
X    equal(one+4, "mn", 4);            /* Wrote too much? */
X
X    (void) strcpy(one, "gh");
X    (void) strcpy(two, "ef");
X    (void) strncat(one, two, 99);
X    equal(one, "ghef", 5);            /* Basic test encore. */
X    equal(two, "ef", 6);            /* Stomped on source? */
X
X    (void) strcpy(one, "");
X    (void) strncat(one, "", 99);
X    equal(one, "", 7);            /* Boundary conditions. */
X    (void) strcpy(one, "ab");
X    (void) strncat(one, "", 99);
X    equal(one, "ab", 8);
X    (void) strcpy(one, "");
X    (void) strncat(one, "cd", 99);
X    equal(one, "cd", 9);
X
X    (void) strcpy(one, "ab");
X    (void) strncat(one, "cdef", 2);
X    equal(one, "abcd", 10);            /* Count-limited. */
X
X    (void) strncat(one, "gh", 0);
X    equal(one, "abcd", 11);            /* Zero count. */
X
X    (void) strncat(one, "gh", 2);
X    equal(one, "abcdgh", 12);        /* Count and length equal. */
X
X    /*
X     * strncmp - first test as strcmp with big counts, then test
X     * count code.
X     */
X    it = "strncmp";
X    check(strncmp("", "", 99) == 0, 1);    /* Trivial case. */
X    check(strncmp("a", "a", 99) == 0, 2);    /* Identity. */
X    check(strncmp("abc", "abc", 99) == 0, 3);    /* Multicharacter. */
X    check(strncmp("abc", "abcd", 99) < 0, 4);    /* Length unequal. */
X    check(strncmp("abcd", "abc", 99) > 0, 5);
X    check(strncmp("abcd", "abce", 99) < 0, 6);    /* Honestly unequal. */
X    check(strncmp("abce", "abcd", 99) > 0, 7);
X    check(strncmp("a\203", "a", 2) > 0, 8);    /* Tricky if '\203' < 0 */
X    if (charsigned)                /* Sign-bit comparison. */
X        check(strncmp("a\203", "a\003", 2) < 0, 9);
X    else
X        check(strncmp("a\203", "a\003", 2) > 0, 9);
X    check(strncmp("abce", "abcd", 3) == 0, 10);    /* Count limited. */
X    check(strncmp("abce", "abc", 3) == 0, 11);    /* Count == length. */
X    check(strncmp("abcd", "abce", 4) < 0, 12);    /* Nudging limit. */
X    check(strncmp("abc", "def", 0) == 0, 13);    /* Zero count. */
X
X    /*
X     * strncpy - testing is a bit different because of odd semantics
X     */
X    it = "strncpy";
X    check(strncpy(one, "abc", 4) == one, 1);    /* Returned value. */
X    equal(one, "abc", 2);            /* Did the copy go right? */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) strncpy(one, "xyz", 2);
X    equal(one, "xycdefgh", 3);        /* Copy cut by count. */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) strncpy(one, "xyz", 3);        /* Copy cut just before NUL. */
X    equal(one, "xyzdefgh", 4);
X
X    (void) strcpy(one, "abcdefgh");
X    (void) strncpy(one, "xyz", 4);        /* Copy just includes NUL. */
X    equal(one, "xyz", 5);
X    equal(one+4, "efgh", 6);        /* Wrote too much? */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) strncpy(one, "xyz", 5);        /* Copy includes padding. */
X    equal(one, "xyz", 7);
X    equal(one+4, "", 8);
X    equal(one+5, "fgh", 9);
X
X    (void) strcpy(one, "abc");
X    (void) strncpy(one, "xyz", 0);        /* Zero-length copy. */
X    equal(one, "abc", 10);
X
X    (void) strncpy(one, "", 2);        /* Zero-length source. */
X    equal(one, "", 11);
X    equal(one+1, "", 12);
X    equal(one+2, "c", 13);
X
X    (void) strcpy(one, "hi there");
X    (void) strncpy(two, one, 9);
X    equal(two, "hi there", 14);        /* Just paranoia. */
X    equal(one, "hi there", 15);        /* Stomped on source? */
X
X    /*
X     * strlen
X     */
X    it = "strlen";
X    check(strlen("") == 0, 1);        /* Empty. */
X    check(strlen("a") == 1, 2);        /* Single char. */
X    check(strlen("abcd") == 4, 3);        /* Multiple chars. */
X
X    /*
X     * strchr
X     */
X    it = "strchr";
X    check(strchr("abcd", 'z') == NULL, 1);    /* Not found. */
X    (void) strcpy(one, "abcd");
X    check(strchr(one, 'c') == one+2, 2);    /* Basic test. */
X    check(strchr(one, 'd') == one+3, 3);    /* End of string. */
X    check(strchr(one, 'a') == one, 4);    /* Beginning. */
X    check(strchr(one, '\0') == one+4, 5);    /* Finding NUL. */
X    (void) strcpy(one, "ababa");
X    check(strchr(one, 'b') == one+1, 6);    /* Finding first. */
X    (void) strcpy(one, "");
X    check(strchr(one, 'b') == NULL, 7);    /* Empty string. */
X    check(strchr(one, '\0') == one, 8);    /* NUL in empty string. */
X
X    /*
X     * index - just like strchr
X     */
X    it = "index";
X    check(index("abcd", 'z') == NULL, 1);    /* Not found. */
X    (void) strcpy(one, "abcd");
X    check(index(one, 'c') == one+2, 2);    /* Basic test. */
X    check(index(one, 'd') == one+3, 3);    /* End of string. */
X    check(index(one, 'a') == one, 4);    /* Beginning. */
X    check(index(one, '\0') == one+4, 5);    /* Finding NUL. */
X    (void) strcpy(one, "ababa");
X    check(index(one, 'b') == one+1, 6);    /* Finding first. */
X    (void) strcpy(one, "");
X    check(index(one, 'b') == NULL, 7);    /* Empty string. */
X    check(index(one, '\0') == one, 8);    /* NUL in empty string. */
X
X    /*
X     * strrchr
X     */
X    it = "strrchr";
X    check(strrchr("abcd", 'z') == NULL, 1);    /* Not found. */
X    (void) strcpy(one, "abcd");
X    check(strrchr(one, 'c') == one+2, 2);    /* Basic test. */
X    check(strrchr(one, 'd') == one+3, 3);    /* End of string. */
X    check(strrchr(one, 'a') == one, 4);    /* Beginning. */
X    check(strrchr(one, '\0') == one+4, 5);    /* Finding NUL. */
X    (void) strcpy(one, "ababa");
X    check(strrchr(one, 'b') == one+3, 6);    /* Finding last. */
X    (void) strcpy(one, "");
X    check(strrchr(one, 'b') == NULL, 7);    /* Empty string. */
X    check(strrchr(one, '\0') == one, 8);    /* NUL in empty string. */
X
X    /*
X     * rindex - just like strrchr
X     */
X    it = "rindex";
X    check(rindex("abcd", 'z') == NULL, 1);    /* Not found. */
X    (void) strcpy(one, "abcd");
X    check(rindex(one, 'c') == one+2, 2);    /* Basic test. */
X    check(rindex(one, 'd') == one+3, 3);    /* End of string. */
X    check(rindex(one, 'a') == one, 4);    /* Beginning. */
X    check(rindex(one, '\0') == one+4, 5);    /* Finding NUL. */
X    (void) strcpy(one, "ababa");
X    check(rindex(one, 'b') == one+3, 6);    /* Finding last. */
X    (void) strcpy(one, "");
X    check(rindex(one, 'b') == NULL, 7);    /* Empty string. */
X    check(rindex(one, '\0') == one, 8);    /* NUL in empty string. */
X}
X
Xsecond()
X{
X    /*
X     * strpbrk - somewhat like strchr
X     */
X    it = "strpbrk";
X    check(strpbrk("abcd", "z") == NULL, 1);    /* Not found. */
X    (void) strcpy(one, "abcd");
X    check(strpbrk(one, "c") == one+2, 2);    /* Basic test. */
X    check(strpbrk(one, "d") == one+3, 3);    /* End of string. */
X    check(strpbrk(one, "a") == one, 4);    /* Beginning. */
X    check(strpbrk(one, "") == NULL, 5);    /* Empty search list. */
X    check(strpbrk(one, "cb") == one+1, 6);    /* Multiple search. */
X    (void) strcpy(one, "abcabdea");
X    check(strpbrk(one, "b") == one+1, 7);    /* Finding first. */
X    check(strpbrk(one, "cb") == one+1, 8);    /* With multiple search. */
X    check(strpbrk(one, "db") == one+1, 9);    /* Another variant. */
X    (void) strcpy(one, "");
X    check(strpbrk(one, "bc") == NULL, 10);    /* Empty string. */
X    check(strpbrk(one, "") == NULL, 11);    /* Both strings empty. */
X
X    /*
X     * strstr - somewhat like strchr
X     */
X    it = "strstr";
X    check(strstr("abcd", "z") == NULL, 1);    /* Not found. */
X    check(strstr("abcd", "abx") == NULL, 2);    /* Dead end. */
X    (void) strcpy(one, "abcd");
X    check(strstr(one, "c") == one+2, 3);    /* Basic test. */
X    check(strstr(one, "bc") == one+1, 4);    /* Multichar. */
X    check(strstr(one, "d") == one+3, 5);    /* End of string. */
X    check(strstr(one, "cd") == one+2, 6);    /* Tail of string. */
X    check(strstr(one, "abc") == one, 7);    /* Beginning. */
X    check(strstr(one, "abcd") == one, 8);    /* Exact match. */
X    check(strstr(one, "abcde") == NULL, 9);    /* Too long. */
X    check(strstr(one, "de") == NULL, 10);    /* Past end. */
X    check(strstr(one, "") == one+4, 11);    /* Finding empty. */
X    (void) strcpy(one, "ababa");
X    check(strstr(one, "ba") == one+1, 12);    /* Finding first. */
X    (void) strcpy(one, "");
X    check(strstr(one, "b") == NULL, 13);    /* Empty string. */
X    check(strstr(one, "") == one, 14);    /* Empty in empty string. */
X    (void) strcpy(one, "bcbca");
X    check(strstr(one, "bca") == one+2, 15);    /* False start. */
X    (void) strcpy(one, "bbbcabbca");
X    check(strstr(one, "bbca") == one+1, 16);    /* With overlap. */
X
X    /*
X     * strspn
X     */
X    it = "strspn";
X    check(strspn("abcba", "abc") == 5, 1);    /* Whole string. */
X    check(strspn("abcba", "ab") == 2, 2);    /* Partial. */
X    check(strspn("abc", "qx") == 0, 3);    /* None. */
X    check(strspn("", "ab") == 0, 4);    /* Null string. */
X    check(strspn("abc", "") == 0, 5);    /* Null search list. */
X
X    /*
X     * strcspn
X     */
X    it = "strcspn";
X    check(strcspn("abcba", "qx") == 5, 1);    /* Whole string. */
X    check(strcspn("abcba", "cx") == 2, 2);    /* Partial. */
X    check(strcspn("abc", "abc") == 0, 3);    /* None. */
X    check(strcspn("", "ab") == 0, 4);    /* Null string. */
X    check(strcspn("abc", "") == 3, 5);    /* Null search list. */
X
X    /*
X     * strtok - the hard one
X     */
X    it = "strtok";
X    (void) strcpy(one, "first, second, third");
X    equal(strtok(one, ", "), "first", 1);    /* Basic test. */
X    equal(one, "first", 2);
X    equal(strtok((char *)NULL, ", "), "second", 3);
X    equal(strtok((char *)NULL, ", "), "third", 4);
X    check(strtok((char *)NULL, ", ") == NULL, 5);
X    (void) strcpy(one, ", first, ");
X    equal(strtok(one, ", "), "first", 6);    /* Extra delims, 1 tok. */
X    check(strtok((char *)NULL, ", ") == NULL, 7);
X    (void) strcpy(one, "1a, 1b; 2a, 2b");
X    equal(strtok(one, ", "), "1a", 8);    /* Changing delim lists. */
X    equal(strtok((char *)NULL, "; "), "1b", 9);
X    equal(strtok((char *)NULL, ", "), "2a", 10);
X    (void) strcpy(two, "x-y");
X    equal(strtok(two, "-"), "x", 11);    /* New string before done. */
X    equal(strtok((char *)NULL, "-"), "y", 12);
X    check(strtok((char *)NULL, "-") == NULL, 13);
X    (void) strcpy(one, "a,b, c,, ,d");
X    equal(strtok(one, ", "), "a", 14);    /* Different separators. */
X    equal(strtok((char *)NULL, ", "), "b", 15);
X    equal(strtok((char *)NULL, " ,"), "c", 16);    /* Permute list too. */
X    equal(strtok((char *)NULL, " ,"), "d", 17);
X    check(strtok((char *)NULL, ", ") == NULL, 18);
X    check(strtok((char *)NULL, ", ") == NULL, 19);    /* Persistence. */
X    (void) strcpy(one, ", ");
X    check(strtok(one, ", ") == NULL, 20);    /* No tokens. */
X    (void) strcpy(one, "");
X    check(strtok(one, ", ") == NULL, 21);    /* Empty string. */
X    (void) strcpy(one, "abc");
X    equal(strtok(one, ", "), "abc", 22);    /* No delimiters. */
X    check(strtok((char *)NULL, ", ") == NULL, 23);
X    (void) strcpy(one, "abc");
X    equal(strtok(one, ""), "abc", 24);    /* Empty delimiter list. */
X    check(strtok((char *)NULL, "") == NULL, 25);
X    (void) strcpy(one, "abcdefgh");
X    (void) strcpy(one, "a,b,c");
X    equal(strtok(one, ","), "a", 26);    /* Basics again... */
X    equal(strtok((char *)NULL, ","), "b", 27);
X    equal(strtok((char *)NULL, ","), "c", 28);
X    check(strtok((char *)NULL, ",") == NULL, 29);
X    equal(one+6, "gh", 30);            /* Stomped past end? */
X    equal(one, "a", 31);            /* Stomped old tokens? */
X    equal(one+2, "b", 32);
X    equal(one+4, "c", 33);
X
X    /*
X     * memcmp
X     */
X    it = "memcmp";
X    check(memcmp("a", "a", 1) == 0, 1);    /* Identity. */
X    check(memcmp("abc", "abc", 3) == 0, 2);    /* Multicharacter. */
X    check(memcmp("abcd", "abce", 4) < 0, 3);    /* Honestly unequal. */
X    check(memcmp("abce", "abcd", 4) > 0, 4);
X    check(memcmp("alph", "beta", 4) < 0, 5);
X    if (charsigned)                /* Sign-bit comparison. */
X        check(memcmp("a\203", "a\003", 2) < 0, 6);
X    else
X        check(memcmp("a\203", "a\003", 2) > 0, 6);
X    check(memcmp("abce", "abcd", 3) == 0, 7);    /* Count limited. */
X    check(memcmp("abc", "def", 0) == 0, 8);    /* Zero count. */
X
X    /*
X     * memchr
X     */
X    it = "memchr";
X    check(memchr("abcd", 'z', 4) == NULL, 1);    /* Not found. */
X    (void) strcpy(one, "abcd");
X    check(memchr(one, 'c', 4) == one+2, 2);    /* Basic test. */
X    check(memchr(one, 'd', 4) == one+3, 3);    /* End of string. */
X    check(memchr(one, 'a', 4) == one, 4);    /* Beginning. */
X    check(memchr(one, '\0', 5) == one+4, 5);    /* Finding NUL. */
X    (void) strcpy(one, "ababa");
X    check(memchr(one, 'b', 5) == one+1, 6);    /* Finding first. */
X    check(memchr(one, 'b', 0) == NULL, 7);    /* Zero count. */
X    check(memchr(one, 'a', 1) == one, 8);    /* Singleton case. */
X    (void) strcpy(one, "a\203b");
X    check(memchr(one, 0203, 3) == one+1, 9);    /* Unsignedness. */
X
X    /*
X     * memcpy
X     *
X     * Note that X3J11 says memcpy must work regardless of overlap.
X     * The SVID says it might fail.
X     */
X    it = "memcpy";
X    check(memcpy(one, "abc", 4) == one, 1);    /* Returned value. */
X    equal(one, "abc", 2);            /* Did the copy go right? */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) memcpy(one+1, "xyz", 2);
X    equal(one, "axydefgh", 3);        /* Basic test. */
X
X    (void) strcpy(one, "abc");
X    (void) memcpy(one, "xyz", 0);
X    equal(one, "abc", 4);            /* Zero-length copy. */
X
X    (void) strcpy(one, "hi there");
X    (void) strcpy(two, "foo");
X    (void) memcpy(two, one, 9);
X    equal(two, "hi there", 5);        /* Just paranoia. */
X    equal(one, "hi there", 6);        /* Stomped on source? */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) memcpy(one+1, one, 9);
X    equal(one, "aabcdefgh", 7);        /* Overlap, right-to-left. */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) memcpy(one+1, one+2, 7);
X    equal(one, "acdefgh", 8);        /* Overlap, left-to-right. */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) memcpy(one, one, 9);
X    equal(one, "abcdefgh", 9);        /* 100% overlap. */
X
X    /*
X     * memccpy - first test like memcpy, then the search part
X     *
X     * The SVID, the only place where memccpy is mentioned, says
X     * overlap might fail, so we don't try it.  Besides, it's hard
X     * to see the rationale for a non-left-to-right memccpy.
X     */
X    it = "memccpy";
X    check(memccpy(one, "abc", 'q', 4) == NULL, 1);    /* Returned value. */
X    equal(one, "abc", 2);            /* Did the copy go right? */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) memccpy(one+1, "xyz", 'q', 2);
X    equal(one, "axydefgh", 3);        /* Basic test. */
X
X    (void) strcpy(one, "abc");
X    (void) memccpy(one, "xyz", 'q', 0);
X    equal(one, "abc", 4);            /* Zero-length copy. */
X
X    (void) strcpy(one, "hi there");
X    (void) strcpy(two, "foo");
X    (void) memccpy(two, one, 'q', 9);
X    equal(two, "hi there", 5);        /* Just paranoia. */
X    equal(one, "hi there", 6);        /* Stomped on source? */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) strcpy(two, "horsefeathers");
X    check(memccpy(two, one, 'f', 9) == two+6, 7);    /* Returned value. */
X    equal(one, "abcdefgh", 8);        /* Source intact? */
X    equal(two, "abcdefeathers", 9);        /* Copy correct? */
X
X    (void) strcpy(one, "abcd");
X    (void) strcpy(two, "bumblebee");
X    check(memccpy(two, one, 'a', 4) == two+1, 10);    /* First char. */
X    equal(two, "aumblebee", 11);
X    check(memccpy(two, one, 'd', 4) == two+4, 12);    /* Last char. */
X    equal(two, "abcdlebee", 13);
X    (void) strcpy(one, "xyz");
X    check(memccpy(two, one, 'x', 1) == two+1, 14);    /* Singleton. */
X    equal(two, "xbcdlebee", 15);
X
X    /*
X     * memset
X     */
X    it = "memset";
X    (void) strcpy(one, "abcdefgh");
X    check(memset(one+1, 'x', 3) == one+1, 1);    /* Return value. */
X    equal(one, "axxxefgh", 2);        /* Basic test. */
X
X    (void) memset(one+2, 'y', 0);
X    equal(one, "axxxefgh", 3);        /* Zero-length set. */
X
X    (void) memset(one+5, 0, 1);
X    equal(one, "axxxe", 4);            /* Zero fill. */
X    equal(one+6, "gh", 5);            /* And the leftover. */
X
X    (void) memset(one+2, 010045, 1);
X    equal(one, "ax\045xe", 6);        /* Unsigned char convert. */
X
X    /*
X     * bcopy - much like memcpy
X     *
X     * Berklix manual is silent about overlap, so don't test it.
X     */
X    it = "bcopy";
X    (void) bcopy("abc", one, 4);
X    equal(one, "abc", 1);            /* Simple copy. */
X
X    (void) strcpy(one, "abcdefgh");
X    (void) bcopy("xyz", one+1, 2);
X    equal(one, "axydefgh", 2);        /* Basic test. */
X
X    (void) strcpy(one, "abc");
X    (void) bcopy("xyz", one, 0);
X    equal(one, "abc", 3);            /* Zero-length copy. */
X
X    (void) strcpy(one, "hi there");
X    (void) strcpy(two, "foo");
X    (void) bcopy(one, two, 9);
X    equal(two, "hi there", 4);        /* Just paranoia. */
X    equal(one, "hi there", 5);        /* Stomped on source? */
X
X    /*
X     * bzero
X     */
X    it = "bzero";
X    (void) strcpy(one, "abcdef");
X    bzero(one+2, 2);
X    equal(one, "ab", 1);            /* Basic test. */
X    equal(one+3, "", 2);
X    equal(one+4, "ef", 3);
X
X    (void) strcpy(one, "abcdef");
X    bzero(one+2, 0);
X    equal(one, "abcdef", 4);        /* Zero-length copy. */
X
X    /*
X     * bcmp - somewhat like memcmp
X     */
X    it = "bcmp";
X    check(bcmp("a", "a", 1) == 0, 1);    /* Identity. */
X    check(bcmp("abc", "abc", 3) == 0, 2);    /* Multicharacter. */
X    check(bcmp("abcd", "abce", 4) != 0, 3);    /* Honestly unequal. */
X    check(bcmp("abce", "abcd", 4) != 0, 4);
X    check(bcmp("alph", "beta", 4) != 0, 5);
X    check(bcmp("abce", "abcd", 3) == 0, 6);    /* Count limited. */
X    check(bcmp("abc", "def", 0) == 0, 8);    /* Zero count. */
X
X#ifdef ERR
X    /*
X     * strerror - VERY system-dependent
X     */
X    it = "strerror";
X    f = open("/", 1);    /* Should always fail. */
X    check(f < 0 && errno > 0 && errno < sys_nerr, 1);
X    equal(strerror(errno), sys_errlist[errno], 2);
X#ifdef UNIXERR
X    equal(strerror(errno), "Is a directory", 3);
X#endif
X#ifdef BERKERR
X    equal(strerror(errno), "Permission denied", 3);
X#endif
X#endif
X}
END_OF_FILE
if test 19922 -ne `wc -c <'libc/strings/tester.c'`; then
    echo shar: \"'libc/strings/tester.c'\" unpacked with wrong size!
fi
# end of 'libc/strings/tester.c'
fi
if test -f 'rnews/headers.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'rnews/headers.c'\"
else
echo shar: Extracting \"'rnews/headers.c'\" \(18247 characters\)
sed "s/^X//" >'rnews/headers.c' <<'END_OF_FILE'
X/*
X * Usenet header parsing and generation (see RFCs 850 & 822;
X *    for a second opinion, see The Hideous Name by Pike & Weinberger).
X *
X * Headers are parsed and modified and copied in one pass.
X * Nevertheless, this file is split into two pieces: header parsing
X * and remembering (aka eating) and header copying (aka munging).
X * The split is marked and the two pieces are fairly independent.
X *
X * --- a quick tour of RFC 850 headers.  Hold on tight ---
X *
X * mandatory headers follow:
X * Path: ucbvax!ukc!decvax!mcvax!ih*!kaist!mh*!ho*!brahms!nsu    # must prepend to
X * From: [e-mail] (Arthur ``Two-Sheds'' Jackson)
X * Newsgroups: talk.philosophy.meaning.meaning
X * Subject: Re: RE: re: rE: Orphaned Response - (nf)    # previously Title:
X * Date: Sat, 25-Dec-86 04:05:06 GMT    # previously Posted:
X * Message-ID: <[e-mail]> # previously Article-I.D.:
X *
X * optional headers follow:
X * Relay-Version: C;utcs            # must replace; must be 1st (recently demoted)
X * Posting-Version: version C alpha;site utcs.uucp    # (recently demoted)
X * Date-Received: Sat, 25-Jan-87 12:34:56 GMT    # must replace or snuff * # previously Received:
X * Organization: UCB society for arguing the meaning of meaning
X * Distribution: ucb
X * Sender: [e-mail]
X * Followup-To: talk.tv.i.love.lucy
X * Control: newgroup talk.philosophy.meaning.meaning.meaning    # magic; not for the uninitiated
X * References: <[e-mail]> <[e-mail]>
X * Reply-To: [e-mail]
X * Expires: Sun, 31-dec-99 23:59:59 GMT
X * Approved: [e-mail]        # the mark of the moderator
X * Lines: 6766                    # redundant & pointless `wc -l`
X *
X * new headers not (yet?) in RFC850 follow:
X * Summary: It was a dark and stormy night,    # retain
X * Keywords: toadsexing, ether, tetanus        # retain
X * Nf-*: transmitted via Notesviles        # might snuff
X *
X * abusive & silly non-RFC-850 headers follow:
X * Sccs-Id: @(#) 5.2.vax.2.women.only  rob  3/5/83
X * Hideous-Name: psuvax1!rhea::@brl.arpa:ucbvax!mit-mc%udel-relay.arpa@chris:umcp-cs::udel-relay%csnet-relay.vision.ubc.cdn
X * Shoe-Size: 8
X * Header-Questions-To: [e-mail]
X * Upas-To: [e-mail]
X * V9-Capable-Machines-To: utstat!geoff
X * Uglix-Version: 5.3.vax.1.4/7/85.21:37:45.binary.only
X *
X * --- Ah well, it will only get worse. ---
X */
X
X#include <stdio.h>
X#include <ctype.h>
X#include <sys/types.h>
X#include "news.h"
X#include "headers.h"
X
X#ifndef DEFDIST
X#define DEFDIST "world"        /* default Distribution: */
X#endif
X#ifndef DEFMSGID
X#define DEFMSGID "<[e-mail]>"
X#endif
X
X#define JUNK "junk"
X#define ALL "all"
X
X#define OLDCNTRL "all.all.ctl"
X
X/*
X * Derivation: 752 is a large header, 120 is approx. size of *-Version because
X *    this rnews throws them away.  HDRMEMSIZ can be too small if
X *    memory is tight and will only hurt performance.
X */
X#ifndef HDRMEMSIZ
X#ifndef notdef
X#define HDRMEMSIZ 8192            /* room for headers */
X#else
X#define HDRMEMSIZ (752-120)
X#endif    /* notdef */
X#endif    /* HDRMEMSIZ */
X
X    /* from here down are recognised in eatheaders() */
Xstatic char ctlnm[] =    "Control:";
Xstatic char distrnm[] =    "Distribution:";
Xstatic char appnm[] =    "Approved:";
Xstatic char subjnm[] =    "Subject:";
Xstatic char msgnm[] =    "Message-ID:";
Xstatic char artidnm[] =    "Article-I.D.:";    /* obsolete Message-ID: */
X    /* from here down recognised by mungehdrs() */
Xstatic char pathnm[] =    "Path:";        /* so we can extend it (damn) */
Xstatic char ngsnm[] = "Newsgroups:";        /* to clone for Xref */
X    /* down to here recognised by eatheaders() */
Xstatic char xrefnm[] = "Xref:";            /* to *replace* Xref (damn!)*/
X    /*
X     * the following noxious headers are deleted because
X     * neighbours still send them and they are big.
X     * in an ideal world, they wouldn't be sent and thus
X     * we wouldn't need to delete them.
X     */
X/* TODO: what about Posted: and Article-I.D.:? */
Xstatic char datercvnm[] = "Date-Received:";    /* so we can snuff it */
Xstatic char rcvnm[] = "Received:";        /* obsolete Date-Received: */
Xstatic char rlyversnm[] = "Relay-Version:";    /* so we can snuff it */
Xstatic char postversnm[] = "Posting-Version:";    /* so we can snuff it */
X    /* down to here recognised by mungehdrs() */
X
X
X/* TODO: permit multiples of hdrprs and hpsp */
Xstruct hdrparsestate {
X    char **prevvalp;    /* points at previous header value string */
X    short prevhist;        /* previous line was a header line */
X    short nextcont;        /* next line must be a header continuation */
X    short newnextcont;    /* nextcont for next line, based on this line */
X    char hdraccum[HDRMEMSIZ+MAXLINE];
X    char *endlnp;        /* pointer to end of input buffer - 1 */
X};
Xstatic struct hdrparsestate hdrprs = { 0, NO, NO, 0 };    /* parser state */
Xstatic struct hdrparsestate *hpsp = &hdrprs;
X/* end of parser state */
X
X
Xstatic int debug = NO;
X
X/* forward decls */
Xchar *skipsp();
X
X/*
X * --- common header code start ---
X */
X
Xhdrdebug(state)
Xint state;
X{
X    debug = state;
X}
X
Xhdrinit(hdrs)            /* zero all pointers in hdrs */
Xregister struct headers *hdrs;
X{
X    hdrs->h_subj = NULL;
X    hdrs->h_ngs = NULL;
X    hdrs->h_files[0] = '\0';
X    hdrs->h_distr = NULL;
X    hdrs->h_ctlcmd = NULL;
X    hdrs->h_approved = NULL;
X    hdrs->h_msgid = NULL;
X    hdrs->h_artid = NULL;
X    hdrs->h_expiry = NULL;
X    hdrs->h_path = NULL;
X    hdrs->h_tmpf[0] = '\0';
X    hdrs->h_unlink = NO;
X    hdrs->h_filed = NO;
X    hdrs->h_xref = NO;
X    hdrs->h_octlchked = NO;
X    hdrs->h_oldctl = NO;
X    hdrs->h_accum = NULL;
X    hdrs->h_charswritten = 0;
X}
X
Xstatic int
Xoldctl(hdrs)            /* true iff ngs are OLDCNTRL (cache in hdrs) */
Xregister struct headers *hdrs;
X{
X    if (!hdrs->h_octlchked) {        /* don't know yet */
X        /* TODO: special case this, avoid ngmatch */
X        hdrs->h_oldctl = ngmatch(OLDCNTRL, hdrs->h_ngs);
X        hdrs->h_octlchked = YES;    /* now we know */
X    }
X    return hdrs->h_oldctl;
X}
X
Xint
Xhdrmutate(hdrs, buffer, tfp)        /* eat & munge headers */
Xstruct headers *hdrs;
Xchar *buffer;
XFILE **tfp;
X{
X        eatheaders(hdrs, buffer);    /* mungehdrs needs n_ngs set */
X    return mungehdrs(buffer, tfp, hdrs);    /* save or write hdr */
X}
X
X/*
X * --- header parsing and remembering starts here ---
X */
X
X/*
X * Reset internal state of header parser.
X * (Empty the stomach of partially-digested headers.  Waarrrgggh!)
X */
Xhdrwretch()
X{
X    hpsp->prevvalp = NULL;
X    hpsp->prevhist = NO;
X    hpsp->nextcont = NO;
X}
X
X/*
X * Parse RFC822/850 header into "hdrs".  Retain significant values.
X * Assumes ishdr has been called first.
X */
Xeatheaders(hdrs, line)
Xregister struct headers *hdrs;
Xregister char *line;
X{
X    /*
X     * One would really like to use a loop through a structure here,
X     * but it's hard because one can't initialise a static struct
X     * with e.g. &hdrs->h_path.
X     */
X    if (!contin(line) &&
X        !hdrmatch(line, pathnm, STRLEN(pathnm), &hdrs->h_path) &&
X        !hdrmatch(line, msgnm,  STRLEN(msgnm),  &hdrs->h_msgid) &&
X        !hdrmatch(line, artidnm,STRLEN(artidnm),&hdrs->h_artid) &&    /* obs. */
X        !hdrmatch(line, subjnm, STRLEN(subjnm), &hdrs->h_subj) &&
X        !hdrmatch(line, ngsnm,  STRLEN(ngsnm),  &hdrs->h_ngs) &&
X        !hdrmatch(line, distrnm,STRLEN(distrnm),&hdrs->h_distr) &&
X        !hdrmatch(line, appnm,  STRLEN(appnm),  &hdrs->h_approved) &&
X        !hdrmatch(line, ctlnm,  STRLEN(ctlnm),  &hdrs->h_ctlcmd)) {
X        static char *dummy = NULL;
X
X        /*
X         * silly header - just set hpsp->prevvalp for contin()
X         * so that unrecognised headers may be continued.
X         */
X        if (dummy != NULL)
X            free(dummy);
X        dummy = strsave("");    /* may be realloced in contin() */
X        hpsp->prevvalp = &dummy;    /* ditto */
X    }
X    hpsp->nextcont = hpsp->newnextcont;    /* set nextcont for next line */
X}
X
Xhdrdeflt(hdrs)                /* default missing header values */
Xregister struct headers *hdrs;
X{
X    /*
X     * if strsave ever returns NULL on failure, instead of exiting,
X     * then the following calls need to check for failure.
X     */
X    if (hdrs->h_ngs == NULL)
X        hdrs->h_ngs = strsave(JUNK);
X    if (hdrs->h_msgid == NULL && hdrs->h_artid != NULL)
X        hdrs->h_msgid = strsave(hdrs->h_artid);
X    if (hdrs->h_msgid == NULL)
X        hdrs->h_msgid = strsave(DEFMSGID);
X    if (hdrs->h_expiry == NULL)
X        hdrs->h_expiry = strsave("-");    /* - means "default" */
X    if (hdrs->h_subj == NULL)
X        hdrs->h_subj = strsave("");
X
X    /*
X     * Control message backwards compatibility, and I mean *backwards*.
X     * We're talking stone age here; we're probably talking A news: if
X     * no Control: header exists and the newsgroup matches all.all.ctl,
X     * use the Subject: as the control message.
X     *
X     * Since RFC 850 is vague on the subject, we will henceforth
X     * internally (but not on disk), treat the Newsgroup: value as
X     * foo.bar, not foo.bar.ctl.  This simplifies the rest of
X     * processing somewhat.
X     */
X    if (hdrs->h_ctlcmd == NULL && oldctl(hdrs)) {
X        hdrs->h_ctlcmd = strsave(hdrs->h_subj);
X        hdrs->h_ngs[strlen(hdrs->h_ngs) - STRLEN(".ctl")] = '\0';
X    }
X
X    if (hdrs->h_ctlcmd != NULL)        /* control message */
X        hdrs->h_octlchked = NO;        /* invalidate old comparison */
X    if (hdrs->h_distr == NULL)
X        hdrs->h_distr = strsave(DEFDIST);
X}
X
Xstatic int
Xiscontin(s)                /* is s an RFC 822 header continuation? */
Xregister char *s;
X{
X    return hpsp->nextcont || hpsp->prevhist && iswhite(*s);
X}
X
Xint
Xishdr(s)                /* is s an RFC 822 header line? */
Xchar *s;
X{
X    register char *cp = s;
X
X    if (iscontin(s))
X        hpsp->prevhist = YES;
X    else {
X        register int c;
X
X        /* look for first of NUL, whitespace, colon */
X        while ((c = *cp) != '\0' && !(isascii(c) && isspace(c)) &&
X            c != ':')
X            ++cp;
X        hpsp->prevhist = (c == ':' && cp > s);    /* colon not 1st char */
X    }
X    /*
X     * If this is a header line and there is no trailing newline,
X     * assume fgets couldn't fit a very long header into the buffer
X     * for header lines, so the next line fgets sees must be a
X     * continuation of this line.
X     */
X    if (hpsp->prevhist) {
X#ifndef DIRTYHDRCONT
X        INDEX(cp, '\n', cp);
X        hpsp->newnextcont = (cp == NULL);    /* no \n -> continue */
X#else    /* DIRTYHDRCONT */
X        hpsp->newnextcont =
X            *hpsp->endlnp != '\0' && *hpsp->endlnp != '\n';
X#endif    /* DIRTYHDRCONT */
X    } else
X        hpsp->newnextcont = NO;
X    return hpsp->prevhist;
X}
X
Xint
Xcontin(line)        /* append continuation value to old value */
Xchar *line;
X{
X    /*
X     * If there is a previous header value and this line starts
X     * with whitespace other than a newline, realloc *hpsp->prevvalp
X     * with enough space for the old value, the new value and a NUL.
X     * Then append the new value.
X     */
X    if (hpsp->prevvalp != NULL && iscontin(line)) {
X        char *valp = /* skipsp */ (line);    /* continuation value */
X
X        /* hpsp->prevvalp was previously set in hdrmatch() or eatheaders() */
X        *hpsp->prevvalp = realloc(*hpsp->prevvalp,
X            (unsigned)strlen(*hpsp->prevvalp) + strlen(valp) + 1);
X        if (*hpsp->prevvalp == NULL)
X            warning("realloc failed in contin", "");
X        else {
X            (void) strcat(*hpsp->prevvalp, valp);
X            trim(*hpsp->prevvalp);    /* remove trailing newline */
X        }
X        return YES;
X    } else
X        return NO;
X}
X
X/*
X * Match line with keyword (return truth value).
X * If it matches, store the value in *malloc'ed memory* (N.B.)
X * and set *ptrp to point there.  freeheader() will free this memory.
X */
Xint
Xhdrmatch(line, keyword, keylen, ptrp)
Xregister char *line, *keyword;
Xregister int keylen;            /* an optimisation */
Xregister char **ptrp;            /* make it point at valuep */
X{
X#ifdef notdef
X    register int keylen = strlen(keyword);    /* the slower way */
X#endif
X    register int match = STREQN(line, keyword, keylen);
X
X    if (match && *ptrp != NULL)    /* value already set */
X        free(*ptrp);        /* return storage */
X    if (match && (*ptrp = strsave(skipsp(&line[keylen]))) != NULL) {
X        trim(*ptrp);        /* remove trailing new line */
X        hpsp->prevvalp = ptrp;    /* for contin() */
X    }
X    return match;
X}
X
Xfreeheaders(hdrs)        /* free (assumed) malloced storage */
Xregister struct headers *hdrs;
X{
X    nnfree(&hdrs->h_subj);
X    nnfree(&hdrs->h_ngs);
X    nnfree(&hdrs->h_distr);
X    nnfree(&hdrs->h_ctlcmd);
X    nnfree(&hdrs->h_approved);
X    nnfree(&hdrs->h_msgid);
X    nnfree(&hdrs->h_artid);
X    nnfree(&hdrs->h_expiry);
X    nnfree(&hdrs->h_path);
X}
X
Xnnfree(mempp)                /* free non-null pointer's memory */
Xregister char **mempp;            /* pointer to malloc'ed ptr. */
X{
X    if (*mempp != NULL) {
X        free(*mempp);
X        *mempp = NULL;
X    }
X}
X
Xint
Xemitxref(tf, hdrs)        /* splat out an Xref: line from Newsgroups: */
Xregister FILE *tf;
Xstruct headers *hdrs;
X{
X    register char *slashp;
X    int status = ST_OKAY;
X    char xrefs[MAXLINE];
X
X    if (!hdrs->h_xref) {        /* this article has no Xref: yet */
X        hdrs->h_xref = YES;
X        (void) strcpy(xrefs, hdrs->h_files);
X        /* turn slashes into colons for the benefit of rn */
X        for (slashp = xrefs; (slashp = index(slashp, FNDELIM)) != NULL; )
X            *slashp++ = ':';
X        if (fprintf(tf, "%s %s %s\n", xrefnm, hostname(), xrefs) == EOF)
X            status = fulldisk(status|ST_DROPPED,
X                (hdrs->h_unlink? hdrs->h_tmpf: hdrs->h_files));
X    }
X    return status;
X}
X
X/*
X * --- header munging (copying) starts here ---
X */
X
X/*
X * Copy headers and munge a few.  Assumes eatheaders has been called.
X *
X * Don't copy Date-Received nor *-Version nor Xref.
X * Prepend hostname! to Path: value.
X * Recognise Newsgroups: and if more than one, generate Xref: &
X * leave holes for the article numbers - fileart will fill them in.
X * (Make rn look in history instead?)
X *
X * (Header munging should be a felony.  When they make me dictator,
X * it will be: punishable by having to use 4.2BSD networking.)
X *
X * New strategy: pile up headers into a static buffer until
X * end of buffer (next line might not fit) [checked in hdrsave()]; end of
X * headers, file or byte count [checked in cparttofp].
X * During reading, discard swill headers.  Path: is munged on output.
X * Copy (save) or discard header lines.
X */
Xint
Xmungehdrs(buffer, tfp, hdrs)
Xregister char *buffer;
Xregister FILE **tfp;
Xstruct headers *hdrs;
X{
X    struct vilesthdrs {
X        char *vh_name;
X        unsigned vh_len;
X    };
X    register struct vilesthdrs *vhp;
X    static struct vilesthdrs vilest[] = {
X        datercvnm,    STRLEN(datercvnm),
X        rcvnm,        STRLEN(rcvnm),
X        rlyversnm,    STRLEN(rlyversnm),
X        postversnm,    STRLEN(postversnm),
X        xrefnm,        STRLEN(xrefnm),
X        NULL,        0
X    };
X
X    if (debug)
X        (void) fputs(buffer, stderr);
X    /*
X     * Toss the most vile of the trash headers.
X     * In an ideal world, this code wouldn't exist.
X     */
X    for (vhp = vilest; vhp->vh_name != NULL; vhp++)
X        if (STREQN(buffer, vhp->vh_name, (int)vhp->vh_len))
X            return ST_OKAY;
X    /* wasn't vile; save it.  *tfp may be NULL.  Be Prepared. */
X    return hdrsave(buffer, hdrs, tfp);    /* may set *tfp */
X}
X
X/*
X * If headers already dumped (hdrs->h_filed), just write to *tfp.
X * If there is room, stash "hdr" away until Newsgroups: is seen,
X * then open the first article link (on *tfp)
X * and dump the saved headers to it.
X * Copy into hdrs->h_accum (TODO: read in directly, iff high on profile).
X * TODO: may want an end-of-accum pointer for speed, iff high on profile.
X */
Xint
Xhdrsave(hdr, hdrs, tfp)
Xchar *hdr;
Xregister struct headers *hdrs;
XFILE **tfp;
X{
X    int status = ST_OKAY;
X    unsigned hdrlen = strlen(hdr);
X
X    if (hdrs->h_filed)            /* *tfp != NULL */
X        return emithdr(hdrs, hdr, *tfp);
X    if (hdrs->h_accum == NULL) {
X        hdrs->h_accum = hpsp->hdraccum;    /* primitive storage allocation */
X        hdrs->h_accum[0] = '\0';
X        hdrs->h_bytesleft = sizeof hpsp->hdraccum;
X    }
X    if (hdrs->h_bytesleft > hdrlen) {    /* it fits! */
X        (void) strcat(hdrs->h_accum, hdr);    /* whomp it on the end */
X        hdrs->h_bytesleft -= hdrlen;
X    } else {                /* no room; barf out headers */
X        status |= hdrdump(tfp, hdrs, NO);    /* don't trigger fileart */
X        if (*tfp != NULL)
X            status |= emithdr(hdrs, hdr, *tfp);
X    }
X    return status;
X}
X
Xstatic int
Xemithdr(hdrs, hdr, tf)    /* munge Path: else just dump the header (hdr) */
Xregister struct headers *hdrs;
Xchar *hdr;
XFILE *tf;
X{
X    register int status = ST_OKAY;
X
X    if (STREQN(hdr, pathnm, STRLEN(pathnm))) {    /* Path: */
X        register int hdrbytes;
X        register char *oldpath;
X
X        oldpath = skipsp(&hdr[STRLEN(pathnm)]);
X        hdrbytes = fprintf(tf, "%s %s!", pathnm, hostname());
X        if (hdrbytes == EOF || fputs(oldpath, tf) == EOF)
X            status = fulldisk(status|ST_DROPPED,
X                (hdrs->h_unlink? hdrs->h_tmpf: hdrs->h_files));
X        else
X            hdrs->h_charswritten += hdrbytes + strlen(oldpath);
X    } else {                    /* ordinary header */
X        if (fputs(hdr, tf) == EOF)
X            status = fulldisk(status|ST_DROPPED,
X                (hdrs->h_unlink? hdrs->h_tmpf: hdrs->h_files));
X        else
X            hdrs->h_charswritten += strlen(hdr);
X    }
X    return status;
X}
X
X/*
X * Barf out headers after opening on *tfp either a temporary file (using
X * mktemp(3)) or the first article link, based on the h_ngs & nxtartnum();
X * set h_tmpf to which ever name is opened.  Modify Path: value on the way.
X */
Xint
Xhdrdump(tfp, hdrs, allhdrsseen)
XFILE **tfp;
Xregister struct headers *hdrs;
Xint allhdrsseen;
X{
X    int status = ST_OKAY;
X
X    if (hdrs->h_filed)
X        return status;
X    /*
X     * If all headers were seen & the group was not an old backward-
X     * compatible control group (which won't exist), then open the
X     * first link, link to the rest, generate Xref:, else open a
X     * temporary name and write the article there
X     * (it will get filed later in insart()).
X     */
X    if (allhdrsseen && hdrs->h_ngs != NULL && !oldctl(hdrs))
X        status |= fileart(hdrs, tfp, 1);
X    else {
X        (void) strcpy(hdrs->h_tmpf, SPOOLTMP);
X        (void) mktemp(hdrs->h_tmpf);    /* make a temporary name */
X        hdrs->h_unlink = 1;        /* unlink it when done */
X        if ((*tfp = fopen(hdrs->h_tmpf, "w")) == NULL) {
X            warning("can't open temporary name `%s'", hdrs->h_tmpf);
X            status |= ST_DROPPED;
X        }
X    }
X    if (*tfp != NULL) {
X        register char *line, *nlp;
X        register int saved;
X
X        /* this is a deadly tedious job and I really should automate it */
X        for (line = hdrs->h_accum; line != NULL && line[0] != '\0';
X             line = nlp) {
X                 /*
X                  * Could this call on INDEX be eliminated without
X                  * restricting the number of header lines?
X                  */
X                 INDEX(line, '\n', nlp);
X            if (nlp != NULL) {
X                ++nlp;        /* byte after \n is NUL or text */
X                saved = *nlp;
X                *nlp = '\0';    /* will be restored below */
X            }
X            if (emithdr(hdrs, line, *tfp) == EOF)    /* dump saved headers */
X                status = fulldisk(status|ST_DROPPED,
X                    (hdrs->h_unlink? hdrs->h_tmpf: hdrs->h_files));
X                 if (nlp != NULL)
X                     *nlp = saved;    /* restore  */
X        }
X    }
X#ifdef notdef
X    hdrs->h_accum = NULL;        /* primitive memory deallocation */
X#endif
X    return status;
X}
END_OF_FILE
if test 18247 -ne `wc -c <'rnews/headers.c'`; then
    echo shar: \"'rnews/headers.c'\" unpacked with wrong size!
fi
# end of 'rnews/headers.c'
fi
echo shar: End of archive 12 \(of 14\).
##  End of shell archive.
exit 0